#include "predicates.h"
#include <vector>

namespace abc_query
{
    class QueryExecutor
    {
    public:
        static std::vector<abc::AbcNodePtr> findNodes(
            const abc::AbcArchive::Ptr &archive,
            const std::shared_ptr<Predicate> &predicate)
        {

            std::vector<abc::AbcNodePtr> result;
            for (const auto &node : archive->nodes())
            {
                if (predicate->testNode(node))
                {
                    result.push_back(node);
                }
                // 递归处理子节点
                collectNodes(node, predicate, result);
            }
            return result;
        }

        static std::vector<abc::AbcFunctionPtr> findFunctions(
            const abc::AbcArchive::Ptr &archive,
            const std::shared_ptr<Predicate> &predicate)
        {

            std::vector<abc::AbcFunctionPtr> result;
            for (const auto &node : archive->nodes())
            {
                collectFunctions(node, predicate, result);
            }
            return result;
        }

    private:
        static void collectNodes(
            const abc::AbcNodePtr &node,
            const std::shared_ptr<Predicate> &predicate,
            std::vector<abc::AbcNodePtr> &result)
        {

            // 如果有子节点结构，可以在这里递归处理
            // 根据您的数据结构可能需要调整
        }

        static void collectFunctions(
            const abc::AbcNodePtr &node,
            const std::shared_ptr<Predicate> &predicate,
            std::vector<abc::AbcFunctionPtr> &result)
        {

            // 收集当前节点的函数
            for (const auto &func : node->functions)
            {
                if (predicate->testFunction(func))
                {
                    result.push_back(func);
                }
            }

            // 递归处理子节点
            // 根据您的数据结构可能需要调整
        }
    };
}